package com.warom.sdg.websocket;

import android.content.Context;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;
import com.warom.sdg.websocket.handler.CommandHandler;
import com.warom.sdg.websocket.handler.NotificationHandler;
import com.warom.sdg.websocket.listener.WebSocketMessageListener;

/**
 * WebSocket消息处理器
 * 负责解析和处理WebSocket消息
 */
public class WebSocketMessageHandler {
    private static final String TAG = "WebSocketMsgHandler";
    private static final Gson gson = new Gson();

    // 消息类型常量
    public static final String TYPE_HEARTBEAT = "heartbeat";
    public static final String TYPE_COMMAND = "command";
    public static final String TYPE_CONTROL_SINGLE = "controlSingle";
    public static final String TYPE_NOTIFICATION = "notification";
    public static final String TYPE_DATA = "data";

    // 上下文
    private final Context context;

    // 消息监听器（用于向外部传递事件）
    private WebSocketMessageListener messageListener;

    // 消息处理器
    private final CommandHandler commandHandler;
    private final NotificationHandler notificationHandler;

    /**
     * 构造函数
     * 
     * @param context         上下文
     * @param webSocketClient WebSocket客户端
     * @param callback        命令回调
     */
    public WebSocketMessageHandler(Context context, WebSocketClient webSocketClient,
            CommandHandler.CommandCallback callback) {
        this.context = context;

        // 初始化处理器
        this.commandHandler = new CommandHandler(context, webSocketClient, callback);
        this.notificationHandler = new NotificationHandler(context);
    }

    /**
     * 设置消息监听器
     * 
     * @param listener 消息监听器
     */
    public void setMessageListener(WebSocketMessageListener listener) {
        this.messageListener = listener;
    }

    /**
     * 处理接收到的消息
     * 
     * @param messageStr 消息内容字符串
     */
    public void handleMessage(String messageStr) {
        if (messageStr == null || messageStr.isEmpty()) {
            Log.e(TAG, "收到空消息");
            return;
        }

        // 检查消息是否是有效的JSON格式
        if (!isValidJson(messageStr)) {
            Log.e(TAG, "收到无效的JSON格式消息: " + messageStr);
            return;
        }

        try {
            // 解析消息为WebSocketMessage对象
            WebSocketMessage message = WebSocketMessage.fromJson(messageStr);
            
            // 获取消息类型
            String type = message.getType() != null ? message.getType() : "unknown";

            // 根据消息类型处理
            switch (type) {
                case TYPE_HEARTBEAT:
                    handleHeartbeat(message);
                    break;

                case TYPE_COMMAND:
                    handleCommand(message);
                    break;

                case TYPE_NOTIFICATION:
                    handleNotification(message);
                    break;

                case TYPE_DATA:
                    handleData(message);
                    break;

                default:
                    handleUnknownMessage(message);
                    break;
            }

        } catch (JsonSyntaxException e) {
            Log.e(TAG, "JSON解析错误: " + e.getMessage(), e);
        } catch (Exception e) {
            Log.e(TAG, "处理消息异常: " + e.getMessage(), e);
        }
    }

    /**
     * 检查字符串是否是有效的JSON格式
     * 
     * @param json 要检查的字符串
     * @return 是否是有效的JSON
     */
    private boolean isValidJson(String json) {
        try {
            JsonParser.parseString(json);
            return true;
        } catch (JsonSyntaxException e) {
            return false;
        }
    }

    /**
     * 处理心跳消息
     * 
     * @param message 心跳消息
     */
    private void handleHeartbeat(WebSocketMessage message) {
        // 转换为JsonObject以保持与现有接口兼容
        JsonObject data = convertContentToJsonObject(message.getContent());
        
        // 心跳消息一般不需要特殊处理，只需通知监听器
        if (messageListener != null) {
            messageListener.onHeartbeat(data);
        }
    }

    /**
     * 处理命令消息
     * 
     * @param message 命令消息
     */
    private void handleCommand(WebSocketMessage message) {
        // 使用命令处理器处理命令
        commandHandler.handleCommand(message);

        // 通知监听器（保持与现有接口兼容）
//        if (messageListener != null) {
//            String command = message.getCommand() != null ? message.getCommand() : "";
//            JsonObject data = convertContentToJsonObject(message.getContent());
//            messageListener.onCommand(command, data);
//        }
    }

    /**
     * 处理通知消息
     * 
     * @param message 通知消息
     */
    private void handleNotification(WebSocketMessage message) {
        String title = message.getTitle() != null ? message.getTitle() : "";
        String messageContent = message.getMessage() != null ? message.getMessage() : "";
        JsonObject data = convertContentToJsonObject(message.getContent());
        
        // 使用通知处理器处理通知
        notificationHandler.handleNotification(title, messageContent, data);

        // 通知监听器
        if (messageListener != null) {
            messageListener.onNotification(title, messageContent, data);
        }
    }

    /**
     * 处理数据消息
     * 
     * @param message 数据消息
     */
    private void handleData(WebSocketMessage message) {
        JsonObject data = convertContentToJsonObject(message.getContent());
        
        // 数据消息只需通知监听器
        if (messageListener != null) {
            messageListener.onData(data);
        }
    }

    /**
     * 处理未知类型消息
     * 
     * @param message 未知类型消息
     */
    private void handleUnknownMessage(WebSocketMessage message) {
        String type = message.getType() != null ? message.getType() : "unknown";
        JsonObject data = convertContentToJsonObject(message.getContent());
        
        Log.d(TAG, "收到未知类型消息: " + type + ", 数据: " + data);

        // 通知监听器
        if (messageListener != null) {
            messageListener.onUnknownMessage(type, data);
        }
    }
    
    /**
     * 将消息内容转换为JsonObject
     * 
     * @param content 消息内容对象
     * @return JsonObject对象
     */
    private JsonObject convertContentToJsonObject(Object content) {
        if (content == null) {
            return new JsonObject();
        }
        
        if (content instanceof JsonObject) {
            return (JsonObject) content;
        }
        
        try {
            // 先将对象转为JSON字符串，再解析为JsonObject
            String json = gson.toJson(content);
            return JsonParser.parseString(json).getAsJsonObject();
        } catch (Exception e) {
            Log.e(TAG, "转换消息内容失败: " + e.getMessage(), e);
            return new JsonObject();
        }
    }

    /**
     * 创建心跳消息
     * 
     * @return 心跳消息JSON字符串
     */
    public static String createHeartbeatMessage() {
        WebSocketMessage message = WebSocketMessage.createHeartbeatMessage();
        return message.toJson();
    }

    /**
     * 创建数据消息
     * 
     * @param data 数据内容
     * @return 数据消息JSON字符串
     */
    public static String createDataMessage(JsonObject data) {
        WebSocketMessage message = new WebSocketMessage();
        message.setType(TYPE_DATA);
        message.setContent(gson.toJson(data));
        message.setTimestamp(System.currentTimeMillis());
        return message.toJson();
    }
}